// 字典管理云对象
module.exports = {
	_before: function () {
		// 通用预处理器
		this.startTime = Date.now();
	},

	/**
	 * 获取字典类型列表
	 * @returns {object} 字典类型列表
	 */
	async getDictTypes() {
		try {
			const db = uniCloud.database();
			
			const result = await db.collection('sh_dict_type')
				.where({ status: 1 })
				.orderBy('sort', 'asc')
				.get();
			
			return {
				errCode: 0,
				errMsg: '获取成功',
				data: result.data
			}
		} catch (error) {
			console.error('获取字典类型列表失败:', error);
			return {
				errCode: 'GET_DICT_TYPES_FAILED',
				errMsg: '获取字典类型列表失败'
			}
		}
	},
	
	/**
	 * 获取字典数据列表
	 * @param {string} type 字典类型
	 * @returns {object} 字典数据列表
	 */
	async getDictItems(type) {
		if (!type) {
			return {
				errCode: 'PARAM_ERROR',
				errMsg: '字典类型不能为空'
			}
		}
		
		try {
			const db = uniCloud.database();
			
			const result = await db.collection('sh_dict_data')
				.where({
					dict_type: type,
					status: 1
				})
				.orderBy('sort', 'asc')
				.get();
			
			return {
				errCode: 0,
				errMsg: '获取成功',
				data: result.data
			}
		} catch (error) {
			console.error('获取字典数据列表失败:', error);
			return {
				errCode: 'GET_DICT_ITEMS_FAILED',
				errMsg: '获取字典数据列表失败'
			}
		}
	},
	
	/**
	 * 获取图案分类列表
	 * @returns {object} 图案分类列表
	 */
	async getPatternCategories() {
		try {
			const db = uniCloud.database();
			
			// 获取图案分类字典
			const result = await db.collection('sh_dict_data')
				.where({
					dict_type: 'pattern_category',
					status: 1
				})
				.orderBy('sort', 'asc')
				.get();
			
			// 转换为标准格式
			const categories = result.data.map(item => ({
				id: item.value,
				value: item.value,
				name: item.label,
				name_en: item.label_en || item.label,
				icon: item.icon || null,
				color: item.color || null,
				sort: item.sort
			}));
			
			return {
				errCode: 0,
				errMsg: '获取成功',
				data: categories
			}
		} catch (error) {
			console.error('获取图案分类列表失败:', error);
			return {
				errCode: 'GET_PATTERN_CATEGORIES_FAILED',
				errMsg: '获取图案分类列表失败'
			}
		}
	},
	
	/**
	 * 获取热门播放列表类型
	 * @returns {object} 热门播放列表类型
	 */
	async getFeaturedPlaylistTypes() {
		try {
			const db = uniCloud.database();
			
			// 获取热门播放列表类型字典
			const result = await db.collection('sh_dict_data')
				.where({
					dict_type: 'featured_playlist_type',
					status: 1
				})
				.orderBy('sort', 'asc')
				.get();
			
			// 转换为标准格式
			const types = result.data.map(item => ({
				id: item.value,
				value: item.value,
				name: item.label,
				name_en: item.label_en || item.label,
				background: item.background || null,
				count: item.count || 0,
				sort: item.sort
			}));
			
			return {
				errCode: 0,
				errMsg: '获取成功',
				data: types
			}
		} catch (error) {
			console.error('获取热门播放列表类型失败:', error);
			return {
				errCode: 'GET_FEATURED_PLAYLIST_TYPES_FAILED',
				errMsg: '获取热门播放列表类型失败'
			}
		}
	},
			
	
	/**
	 * 创建字典类型
	 * @param {object} params 字典类型参数
	 * @returns {object} 创建结果
	 */
	async createDictType(params) {
		// 检查管理员权限
		const { uid } = this.getClientInfo();
		if (!uid) {
			return {
				errCode: 'NOT_LOGGED_IN',
				errMsg: '用户未登录'
			}
		}
		
		// 检查必填参数
		if (!params.dict_name || !params.dict_type) {
			return {
				errCode: 'PARAM_ERROR',
				errMsg: '名称和类型不能为空'
			}
		}
		
		try {
			const db = uniCloud.database();
			
			// 检查类型是否已存在
			const existCheck = await db.collection('sh_dict_type')
				.where({
					dict_type: params.dict_type
				})
				.count();
			
			if (existCheck.total > 0) {
				return {
					errCode: 'TYPE_ALREADY_EXISTS',
					errMsg: '字典类型已存在'
				}
			}
			
			// 创建字典类型
			const dictType = {
				dict_name: params.dict_name,
				dict_type: params.dict_type,
				description: params.description || '',
				status: params.status || 1,
				remark: params.remark || '',
				create_time: new Date(),
				create_uid: uid
			};
			
			const result = await db.collection('sh_dict_type').add(dictType);
			
			return {
				errCode: 0,
				errMsg: '创建成功',
				data: {
					id: result.id
				}
			}
		} catch (error) {
			console.error('创建字典类型失败:', error);
			return {
				errCode: 'CREATE_DICT_TYPE_FAILED',
				errMsg: '创建字典类型失败'
			}
		}
	},
	
	/**
	 * 创建字典数据
	 * @param {object} params 字典数据参数
	 * @returns {object} 创建结果
	 */
	async createDictItem(params) {
		// 检查管理员权限
		const { uid } = this.getClientInfo();
		if (!uid) {
			return {
				errCode: 'NOT_LOGGED_IN',
				errMsg: '用户未登录'
			}
		}
		
		// 检查必填参数
		if (!params.dict_type || !params.label || !params.value) {
			return {
				errCode: 'PARAM_ERROR',
				errMsg: '类型、标签和值不能为空'
			}
		}
		
		try {
			const db = uniCloud.database();
			
			// 检查类型是否存在
			const typeCheck = await db.collection('sh_dict_type')
				.where({
					dict_type: params.dict_type
				})
				.count();
			
			if (typeCheck.total === 0) {
				return {
					errCode: 'TYPE_NOT_EXISTS',
					errMsg: '字典类型不存在'
				}
			}
			
			// 检查值是否已存在
			const existCheck = await db.collection('sh_dict_data')
				.where({
					dict_type: params.dict_type,
					value: params.value
				})
				.count();
			
			if (existCheck.total > 0) {
				return {
					errCode: 'VALUE_ALREADY_EXISTS',
					errMsg: '字典值已存在'
				}
			}
			
			// 创建字典数据
			const dictData = {
				dict_type: params.dict_type,
				label: params.label,
				label_en: params.label_en || params.label,
				value: params.value,
				status: params.status || 1,
				sort: params.sort || 1000,
				icon: params.icon || '',
				color: params.color || '',
				is_default: params.is_default || 0,
				remark: params.remark || '',
				create_time: new Date(),
				create_uid: uid
			};
			
			const result = await db.collection('sh_dict_data').add(dictData);
			
			return {
				errCode: 0,
				errMsg: '创建成功',
				data: {
					id: result.id
				}
			}
		} catch (error) {
			console.error('创建字典数据失败:', error);
			return {
				errCode: 'CREATE_DICT_ITEM_FAILED',
				errMsg: '创建字典数据失败'
			}
		}
	},
	
	/**
	 * 更新字典类型
	 * @param {object} params 字典类型参数
	 * @returns {object} 更新结果
	 */
	async updateDictType(params) {
		// 检查管理员权限
		const { uid } = this.getClientInfo();
		if (!uid) {
			return {
				errCode: 'NOT_LOGGED_IN',
				errMsg: '用户未登录'
			}
		}
		
		// 检查ID参数
		if (!params._id) {
			return {
				errCode: 'PARAM_ERROR',
				errMsg: 'ID不能为空'
			}
		}
		
		try {
			const db = uniCloud.database();
			
			// 更新数据
			const updateData = {
				update_time: new Date()
			};
			
			// 可更新字段
			const allowFields = ['dict_name', 'description', 'status', 'remark'];
			allowFields.forEach(field => {
				if (params[field] !== undefined) {
					updateData[field] = params[field];
				}
			});
			
			const result = await db.collection('sh_dict_type')
				.doc(params._id)
				.update(updateData);
			
			return {
				errCode: 0,
				errMsg: '更新成功',
				data: {
					updated: result.updated
				}
			}
		} catch (error) {
			console.error('更新字典类型失败:', error);
			return {
				errCode: 'UPDATE_DICT_TYPE_FAILED',
				errMsg: '更新字典类型失败'
			}
		}
	},
	
	/**
	 * 更新字典数据
	 * @param {object} params 字典数据参数
	 * @returns {object} 更新结果
	 */
	async updateDictItem(params) {
		// 检查管理员权限
		const { uid } = this.getClientInfo();
		if (!uid) {
			return {
				errCode: 'NOT_LOGGED_IN',
				errMsg: '用户未登录'
			}
		}
		
		// 检查ID参数
		if (!params._id) {
			return {
				errCode: 'PARAM_ERROR',
				errMsg: 'ID不能为空'
			}
		}
		
		try {
			const db = uniCloud.database();
			
			// 更新数据
			const updateData = {
				update_time: new Date()
			};
			
			// 可更新字段
			const allowFields = ['label', 'label_en', 'sort', 'status', 'icon', 'color', 'is_default', 'remark'];
			allowFields.forEach(field => {
				if (params[field] !== undefined) {
					updateData[field] = params[field];
				}
			});
			
			const result = await db.collection('sh_dict_data')
				.doc(params._id)
				.update(updateData);
			
			return {
				errCode: 0,
				errMsg: '更新成功',
				data: {
					updated: result.updated
				}
			}
		} catch (error) {
			console.error('更新字典数据失败:', error);
			return {
				errCode: 'UPDATE_DICT_ITEM_FAILED',
				errMsg: '更新字典数据失败'
			}
		}
	}
}
